home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / controls / RadioButton.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  11.3 KB  |  395 lines
  1. package mx.controls
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.KeyboardEvent;
  5.    import flash.events.MouseEvent;
  6.    import flash.ui.Keyboard;
  7.    import mx.core.FlexVersion;
  8.    import mx.core.IFlexDisplayObject;
  9.    import mx.core.mx_internal;
  10.    import mx.events.FlexEvent;
  11.    import mx.events.ItemClickEvent;
  12.    import mx.managers.IFocusManager;
  13.    import mx.managers.IFocusManagerGroup;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class RadioButton extends Button implements IFocusManagerGroup
  18.    {
  19.       mx_internal static var createAccessibilityImplementation:Function;
  20.       
  21.       mx_internal static const VERSION:String = "3.2.0.3958";
  22.       
  23.       private var _group:RadioButtonGroup;
  24.       
  25.       mx_internal var _groupName:String;
  26.       
  27.       private var _value:Object;
  28.       
  29.       private var groupChanged:Boolean = false;
  30.       
  31.       mx_internal var indexNumber:int = 0;
  32.       
  33.       public function RadioButton()
  34.       {
  35.          super();
  36.          mx_internal::_labelPlacement = "";
  37.          mx_internal::_toggle = true;
  38.          groupName = "radioGroup";
  39.          addEventListener(FlexEvent.ADD,addHandler);
  40.          mx_internal::centerContent = false;
  41.          mx_internal::extraSpacing = 8;
  42.       }
  43.       
  44.       private function addHandler(param1:FlexEvent) : void
  45.       {
  46.          if(!_group && initialized)
  47.          {
  48.             addToGroup();
  49.          }
  50.       }
  51.       
  52.       private function setNext(param1:Boolean = true) : void
  53.       {
  54.          var _loc5_:RadioButton = null;
  55.          var _loc2_:RadioButtonGroup = group;
  56.          var _loc3_:IFocusManager = focusManager;
  57.          if(_loc3_)
  58.          {
  59.             _loc3_.showFocusIndicator = true;
  60.          }
  61.          var _loc4_:int = mx_internal::indexNumber + 1;
  62.          while(_loc4_ < _loc2_.numRadioButtons)
  63.          {
  64.             _loc5_ = _loc2_.getRadioButtonAt(_loc4_);
  65.             if((Boolean(_loc5_)) && _loc5_.enabled)
  66.             {
  67.                if(param1)
  68.                {
  69.                   _loc2_.mx_internal::setSelection(_loc5_);
  70.                }
  71.                _loc5_.setFocus();
  72.                return;
  73.             }
  74.             _loc4_++;
  75.          }
  76.          if(param1 && _loc2_.getRadioButtonAt(mx_internal::indexNumber) != _loc2_.selection)
  77.          {
  78.             _loc2_.mx_internal::setSelection(this);
  79.          }
  80.          this.drawFocus(true);
  81.       }
  82.       
  83.       private function addToGroup() : Object
  84.       {
  85.          var _loc1_:RadioButtonGroup = group;
  86.          if(_loc1_)
  87.          {
  88.             _loc1_.mx_internal::addInstance(this);
  89.          }
  90.          return _loc1_;
  91.       }
  92.       
  93.       override protected function commitProperties() : void
  94.       {
  95.          super.commitProperties();
  96.          if(groupChanged)
  97.          {
  98.             addToGroup();
  99.             groupChanged = false;
  100.          }
  101.       }
  102.       
  103.       override protected function clickHandler(param1:MouseEvent) : void
  104.       {
  105.          if(!enabled || selected)
  106.          {
  107.             return;
  108.          }
  109.          if(!_group)
  110.          {
  111.             addToGroup();
  112.          }
  113.          super.clickHandler(param1);
  114.          group.mx_internal::setSelection(this);
  115.          var _loc2_:ItemClickEvent = new ItemClickEvent(ItemClickEvent.ITEM_CLICK);
  116.          _loc2_.label = label;
  117.          _loc2_.index = mx_internal::indexNumber;
  118.          _loc2_.relatedObject = this;
  119.          _loc2_.item = value;
  120.          group.dispatchEvent(_loc2_);
  121.       }
  122.       
  123.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  124.       {
  125.          super.keyUpHandler(param1);
  126.          if(param1.keyCode == Keyboard.SPACE && !mx_internal::_toggle)
  127.          {
  128.             mx_internal::_toggle = true;
  129.          }
  130.       }
  131.       
  132.       [Bindable("labelPlacementChanged")]
  133.       override public function get labelPlacement() : String
  134.       {
  135.          var _loc1_:String = ButtonLabelPlacement.RIGHT;
  136.          if(mx_internal::_labelPlacement != "")
  137.          {
  138.             _loc1_ = mx_internal::_labelPlacement;
  139.          }
  140.          else if(Boolean(_group) && _group.labelPlacement != "")
  141.          {
  142.             _loc1_ = _group.labelPlacement;
  143.          }
  144.          return _loc1_;
  145.       }
  146.       
  147.       public function set groupName(param1:String) : void
  148.       {
  149.          if(!param1 || param1 == "")
  150.          {
  151.             return;
  152.          }
  153.          mx_internal::deleteGroup();
  154.          mx_internal::_groupName = param1;
  155.          groupChanged = true;
  156.          invalidateProperties();
  157.          invalidateDisplayList();
  158.          dispatchEvent(new Event("groupNameChanged"));
  159.       }
  160.       
  161.       override protected function initializeAccessibility() : void
  162.       {
  163.          if(RadioButton.mx_internal::createAccessibilityImplementation != null)
  164.          {
  165.             RadioButton.mx_internal::createAccessibilityImplementation(this);
  166.          }
  167.       }
  168.       
  169.       private function setThis() : void
  170.       {
  171.          if(!_group)
  172.          {
  173.             addToGroup();
  174.          }
  175.          var _loc1_:RadioButtonGroup = group;
  176.          if(_loc1_.selection != this)
  177.          {
  178.             _loc1_.mx_internal::setSelection(this);
  179.          }
  180.       }
  181.       
  182.       override public function get emphasized() : Boolean
  183.       {
  184.          return false;
  185.       }
  186.       
  187.       override public function get toggle() : Boolean
  188.       {
  189.          return super.toggle;
  190.       }
  191.       
  192.       override protected function measure() : void
  193.       {
  194.          var _loc1_:Number = NaN;
  195.          var _loc2_:Number = NaN;
  196.          var _loc3_:Number = NaN;
  197.          var _loc4_:Number = NaN;
  198.          super.measure();
  199.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  200.          {
  201.             _loc1_ = measureText(label).height;
  202.             _loc2_ = !!mx_internal::currentIcon ? Number(mx_internal::currentIcon.height) : 0;
  203.             if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  204.             {
  205.                _loc3_ = Math.max(_loc1_,_loc2_);
  206.             }
  207.             else
  208.             {
  209.                _loc3_ = _loc1_ + _loc2_;
  210.                _loc4_ = getStyle("verticalGap");
  211.                if(_loc2_ != 0 && !isNaN(_loc4_))
  212.                {
  213.                   _loc3_ += _loc4_;
  214.                }
  215.             }
  216.             measuredMinHeight = measuredHeight = Math.max(_loc3_,18);
  217.          }
  218.       }
  219.       
  220.       override public function set toggle(param1:Boolean) : void
  221.       {
  222.       }
  223.       
  224.       mx_internal function deleteGroup() : void
  225.       {
  226.          try
  227.          {
  228.             if(document[groupName])
  229.             {
  230.                delete document[groupName];
  231.             }
  232.          }
  233.          catch(e:Error)
  234.          {
  235.             try
  236.             {
  237.                if(document.automaticRadioButtonGroups[groupName])
  238.                {
  239.                   delete document.automaticRadioButtonGroups[groupName];
  240.                }
  241.             }
  242.             catch(e1:Error)
  243.             {
  244.             }
  245.          }
  246.       }
  247.       
  248.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  249.       {
  250.          if(!enabled)
  251.          {
  252.             return;
  253.          }
  254.          switch(param1.keyCode)
  255.          {
  256.             case Keyboard.DOWN:
  257.                setNext(!param1.ctrlKey);
  258.                param1.stopPropagation();
  259.                break;
  260.             case Keyboard.UP:
  261.                setPrev(!param1.ctrlKey);
  262.                param1.stopPropagation();
  263.                break;
  264.             case Keyboard.LEFT:
  265.                setPrev(!param1.ctrlKey);
  266.                param1.stopPropagation();
  267.                break;
  268.             case Keyboard.RIGHT:
  269.                setNext(!param1.ctrlKey);
  270.                param1.stopPropagation();
  271.                break;
  272.             case Keyboard.SPACE:
  273.                setThis();
  274.                mx_internal::_toggle = false;
  275.             default:
  276.                super.keyDownHandler(param1);
  277.          }
  278.       }
  279.       
  280.       [Bindable("groupNameChanged")]
  281.       public function get groupName() : String
  282.       {
  283.          return mx_internal::_groupName;
  284.       }
  285.       
  286.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  287.       {
  288.          super.updateDisplayList(param1,param2);
  289.          if(groupChanged)
  290.          {
  291.             addToGroup();
  292.             groupChanged = false;
  293.          }
  294.          if(_group && mx_internal::_selected && _group.selection != this)
  295.          {
  296.             group.mx_internal::setSelection(this,false);
  297.          }
  298.       }
  299.       
  300.       [Bindable("valueChanged")]
  301.       public function get value() : Object
  302.       {
  303.          return _value;
  304.       }
  305.       
  306.       public function set value(param1:Object) : void
  307.       {
  308.          _value = param1;
  309.          dispatchEvent(new Event("valueChanged"));
  310.          if(selected && Boolean(group))
  311.          {
  312.             group.dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  313.          }
  314.       }
  315.       
  316.       private function setPrev(param1:Boolean = true) : void
  317.       {
  318.          var _loc5_:RadioButton = null;
  319.          var _loc2_:RadioButtonGroup = group;
  320.          var _loc3_:IFocusManager = focusManager;
  321.          if(_loc3_)
  322.          {
  323.             _loc3_.showFocusIndicator = true;
  324.          }
  325.          var _loc4_:int = 1;
  326.          while(_loc4_ <= mx_internal::indexNumber)
  327.          {
  328.             _loc5_ = _loc2_.getRadioButtonAt(mx_internal::indexNumber - _loc4_);
  329.             if((Boolean(_loc5_)) && _loc5_.enabled)
  330.             {
  331.                if(param1)
  332.                {
  333.                   _loc2_.mx_internal::setSelection(_loc5_);
  334.                }
  335.                _loc5_.setFocus();
  336.                return;
  337.             }
  338.             _loc4_++;
  339.          }
  340.          if(param1 && _loc2_.getRadioButtonAt(mx_internal::indexNumber) != _loc2_.selection)
  341.          {
  342.             _loc2_.mx_internal::setSelection(this);
  343.          }
  344.          this.drawFocus(true);
  345.       }
  346.       
  347.       public function set group(param1:RadioButtonGroup) : void
  348.       {
  349.          _group = param1;
  350.       }
  351.       
  352.       public function get group() : RadioButtonGroup
  353.       {
  354.          var g:RadioButtonGroup = null;
  355.          if(!document)
  356.          {
  357.             return _group;
  358.          }
  359.          if(!_group)
  360.          {
  361.             if(Boolean(groupName) && groupName != "")
  362.             {
  363.                try
  364.                {
  365.                   g = RadioButtonGroup(document[groupName]);
  366.                }
  367.                catch(e:Error)
  368.                {
  369.                   if(Boolean(document.automaticRadioButtonGroups) && Boolean(document.automaticRadioButtonGroups[groupName]))
  370.                   {
  371.                      g = RadioButtonGroup(document.automaticRadioButtonGroups[groupName]);
  372.                   }
  373.                }
  374.                if(!g)
  375.                {
  376.                   g = new RadioButtonGroup(IFlexDisplayObject(document));
  377.                   if(!document.automaticRadioButtonGroups)
  378.                   {
  379.                      document.automaticRadioButtonGroups = {};
  380.                   }
  381.                   document.automaticRadioButtonGroups[groupName] = g;
  382.                }
  383.                else if(!(g is RadioButtonGroup))
  384.                {
  385.                   return null;
  386.                }
  387.                _group = g;
  388.             }
  389.          }
  390.          return _group;
  391.       }
  392.    }
  393. }
  394.  
  395.